<!DOCTYPE HTML>
<html class="no-js" lang="zh-CN">
<head><meta name="generator" content="Hexo 3.9.0">
    <!--[if lte IE 9]>
<meta http-equiv="refresh" content="0;url=https://grownzd.gitee.io/blog/warn.html">
<![endif]-->
<meta charset="utf-8">
<meta http-equiv="X-DNS-Prefetch-Control" content="on">
<link rel="dns-prefetch" href="https://grownzd.gitee.io/blog">
<link rel="dns-prefetch" href="//www.google-analytics.com">
<link rel="prefetch" href="https://grownzd.gitee.io/blog">
<link rel="prefetch" href="//www.google-analytics.com">


<link rel="prerender" href="https://grownzd.gitee.io/blog">

<meta http-equiv="X-UA-Compatible" content="IE=Edge">
<meta name="renderer" content="webkit">
<meta name="viewport" content="width=device-width, initial-scale=1.0,user-scalable=no">
<meta http-equiv="mobile-agent" content="format=html5; url=https://grownzd.gitee.io/blog">
<meta name="author" content="John Doe">
<link rel="stylesheet" href="/blog/css/JSimple.css">

<link rel="shortcut icon" href="/blog/images/favicon.png">


<title>第1-10天 - Hexo</title>

<meta name="keywords" content>

<meta name="description " content>

    <script type="text/x-mathjax-config">
        MathJax.Hub.Config({
            tex2jax: {
                inlineMath: [ ['$','$'], ["\\(","\\)"] ],
                processEscapes: true
            }
        });
    </script>


    

    

</head>
<body>
<div id="nav">
    <nav class="nav-menu">
        <a class="site-name current" href="/" title="说">说</a>
        <a class="site-index current" href="/"><i class="fa fa-home"></i><span>首页</span></a>
        <a href="/archives" title="归档"><i class="fa fa-archives"></i><span>归档</span></a>
        <a href="/tags" title="标签"><i class="fa fa-tags"></i><span>标签</span></a>
        <!-- custom single page of menus -->
        
        
        <a href="/help" title="帮助">
            <i class="fa fa-question-circle"></i>
            <span>帮助</span>
        </a>
        
    </nav>
</div>

<div class="nav-user">
    <a class="btn-search" href="#"><i class="fa fa-search"></i></a>
    <a class="btn-read-mode" href="#"><i class="fa fa-sun-o"></i></a>
    <a class="btn-sns-qr" href="javascript:"><i class="fa fa-telegram"></i></a>
</div>

<div id="wrapper" class="clearfix">
    <div id="body">
        <div class="main" id="main">
            <div id="cover">
    <div class="cover-img"></div>
    <div class="cover-info">
        
        <h1 class="cover-siteName">说IT</h1>
        <h3 class="cover-siteTitle">用代码摇滚这个世界</h3>
        <p class="cover-siteDesc">一个关注技术与人文的IT博客</p>
        <div class="cover-sns">
            
    &nbsp;&nbsp;<div class="btn btn-telegram">
        <a href="http://t.me/kunyintang" target="_blank" title="telegram" ref="friend">
            <i class="fa fa-telegram"></i>
        </a>
    </div>

    &nbsp;&nbsp;<div class="btn btn-instagram">
        <a href="https://www.instagram.com/mtangsir/" target="_blank" title="instagram" ref="friend">
            <i class="fa fa-instagram"></i>
        </a>
    </div>

    &nbsp;&nbsp;<div class="btn btn-twitter">
        <a href="https://twitter.com/tangkunyin" target="_blank" title="twitter" ref="friend">
            <i class="fa fa-twitter"></i>
        </a>
    </div>

    &nbsp;&nbsp;<div class="btn btn-github">
        <a href="https://github.com/tangkunyin" target="_blank" title="github" ref="friend">
            <i class="fa fa-github"></i>
        </a>
    </div>


        </div>
    </div>
</div>

            <div class="page-title">
    <ul>
        <li><a href="/">最近</a></li>
        
            
                <li class>
                    <a href="/categories/tech-notes" data-name="技术">技术</a>
                </li>
            
                <li class>
                    <a href="/categories/humanities" data-name="人文">人文</a>
                </li>
            
                <li class>
                    <a href="/categories/others" data-name="其他">其他</a>
                </li>
            
        
        <li class="page-search">
    <form id="search" class="search-form">
        <input type="text" readonly="readonly" id="local-search-input-tip" placeholder="读物检索~">
        <button type="button" disabled="disabled" class="search-form-submit"><i class="fa fa-search"></i></button>
    </form>
</li>

    </ul>
</div>
<div class="main-inner">
    <article class="post" itemscope itemtype="http://schema.org/BlogPosting">
        <div class="post-header">
            <div class="post-author clearfix">
                <a class="avatar fleft" href="https://www.tangkunyin.com" target="_blank">
                    <img width="48" src="/images/favicon.png" alt="avatar">
                </a>
                <p><span class="label">作者</span>
                    <a href="https://about.tangkunyin.com" target="_blank">zd</a>
                    <span title="最后编辑于&nbsp;2019-06-23">2019-06-23</span>
                </p>
                <p>一个写代码的「伪文人」</p>
            </div>
            <h2 class="post-title">第1-10天</h2>
            <div class="post-meta">
                本文共计21182个字 |
                您是第&nbsp;<span id="busuanzi_value_page_pv"><i class="fa fa-spinner fa-spin"></i></span>位看到它们的小伙伴
            </div>
        </div>
        <div class="post-content markdown-body">
            <p>肖静茹<br>注意事项：<br>1、记笔记<br>2、多敲<br>3、视频为辅<br>4、打字速度(金山打字通)<br>5、当天内容必须掌握<br>教室要求：<br>1、不能做与学习无关的事情<br>2、不能玩手机，看视频等<br>3、手机静音<br>IT：<br>Information technology 信息技术<br>UI：平面设计，用户交互的界面，PS<br>Web 前端：<br>HTML，CSS，JavaScript，…..<br>后端技术：<br>Java，python,.net,C#…..<br>接收请求后，进行处理(查找、添加等)，将处理后的结果返回给客户<br>数据库：<br>MySQL，Oracle<br>课程介绍：<br>第一阶段：<br>Java 基础，<br>基础语法包括：变量、数据类型、流程控制语句…<br>面向对象<br>集合框架，IO 技术，常用类等<br>第二阶段：<br>JavaWeb 阶段：<br>Web 前端和数据库<br>Servlet，jsp 等<br>第三阶段：<br>框架：<br>springMvc<br>第四阶段：<br>知识点: zooker…<br>实战项目：<br>本阶段：<br>第一周：<br>变量、数据类型、运算符、流程语句、数组<br>第二周：<br>面向对象：封装 继承 多态<br>第三周：<br>常用类型： 字符串类，Object，包装类，Math 等<br>集合框架<br>第四周：<br>集合框架<br>IO 技术<br>第五周：<br>线程<br>网络编程<br>反射<br>JDK1.8 特性<br>技术要点:<br>计算基础：<br>计算机，电脑(PC)<br>宾夕法尼亚大学，1946 年，第一台计算产生，用于军事领域。<br>组成：<br>硬件：<br>看得见，摸得着<br>运算器，控制器，存储器，输入设备，输出设备<br>软件：<br>将一种逻辑用不同的语言进行实现。<br>数据+指令的集合。<br>所有的软件执行需要：内存+CPU<br>计算机识别的数据：二进制数据<br>分类：<br>系统软件：<br>Windows,Linux,Mac<br>应用软件：<br>QQ，WPS…<br>交互方式：<br>图形化界面交互<br>命令行交互<br>触摸、语音<br>常用命令：<br>打开窗口：</p>
<ol>
<li>开始—&gt;附件–&gt;命令提示符</li>
<li>开始–&gt;搜索框输入 cmd </li>
<li>键盘 windows+R—&gt;运行–&gt;cmd（建议）<br>命令：<br>进入指定的目录 ： cd 目录名<br>退回上一级目录 ： cd..<br>退回到根目录： cd\<br>切换盘符： 对应的盘符名:<br>创建文件夹： md 文件夹名<br>删除文件夹： rd 文件夹名 注意：文件夹必须为空<br>删除文件： del 文件名.后缀名<br>编程语言分类：<br>机器语言时代：0,1<br>汇编语言时代：字符、单词、符号。<br>高级语言时代：关键字，对话聊天的感觉。<br>Java 语言基础：<br>发展史：<br>SUN 公司研发，91 年。<br>詹姆斯.高斯林—–oak（橡树）<br>95 年，java（logo:咖啡）<br>Jdk：开发工具包<br>96 年： jdk1.0<br>98 年： jdk1.2<br>J2SE (JavaSE):标准版，桌面应用程序开发<br>J2EE(JavaEE)：企业版，web 应用程序开发<br>J2ME(JavaME)：移动版，淘汰了<br>Jdk5.0<br>Jdk8.0<br>Oracle 公司收购<br>特点：<br>面向对象思想，跨平台特性，编译和运行性，动态性。<br>跨平台：<br>可以在不同的操作系统平台上运行。<br>原理：<br>安装一个 jvm(java 虚拟机)<br>Jvm 是执行 java 程序的。<br>环境搭建：<br>Jvm： java 虚拟机<br>Jre: java runtime environment java 运行环境<br>包含： jvm+类库<br>Jdk: java development kit java 开发工具包<br>包含：jre+开发工具（javac 编译，java 执行）<br>Jdk 包含 jre 包含 jvm<br>Jdk 下载：<br><a href="http://www.oracle.com" target="_blank" rel="noopener">http://www.oracle.com</a><br>Jdk 安装：<br>傻瓜式安装即可<br>安装路径中不建议有空格和中文字符，容易出现的乱码。<br>测试是否安装成功：<br>验证开发工具是否可用。<br>cmd 窗口中：</li>
<li>切换到开发工具所在的目录</li>
<li>输入 java 或者 javac<br>问题：<br>无论光标左侧是什么样的路径，都想要找到 java 或者是 javac。<br>命令的执行一共会查找两个地方：</li>
<li>光标左侧的路径</li>
<li>系统变量中的 path<br>计算机—右键—属性—高级系统设置—高级–环境变量–系<br>统变量<br>Path = C:\Program Files (x86)\Java\jdk1.8.0_131\bin;……..<br>建议配置：<br>Java_Home = C:\Program Files (x86)\Java\jdk1.8.0_131<br>Path = %Java_Home%\bin;….<br>编写编译程序：<br>开发工具：<br>具有编辑性的软件都可以使用，<br>比如：记事本、超级记事本….<br>集成开发工具： eclipse， idea<br>步骤：</li>
<li>创建一个.java 文件</li>
<li>编写源代码</li>
<li>编译源文件，生成新的文件(字节码文件，类文件) javac<br>文件名.java </li>
<li>执行类文件 java 类名<br>注意：</li>
<li>java 语言区分大小写</li>
<li>注意缩进（方便阅读）</li>
<li>一行建议写一条语句<br>模板代码：<br>class 类名{<br>public static void main(String[] args){<br>逻辑代码;<br>}<br>}<br>复习：</li>
<li>环境搭建<br>jvm: java 虚拟机，执行程序<br>jre: java 运行环境，包含：jvm+类库<br>jdk: java 开发工具包，包含：jre+开发工具(javac, java)<br>注意：安装 jdk 时，路径中不要出现中文和空格。<br>环境变量配置：<br>目的：无论在那个路径下都可以使用 javac 和 java。<br>系统变量：<br>Java_Home: …..<br>path：%Java_Home%\bin; </li>
<li>程序编写<br>步骤：</li>
<li>创建一个.java 文件</li>
<li>编写代码</li>
<li>编译 javac 文件名.java </li>
<li>执行 java 类名<br>编译时期：<br>检查的是语法错误<br>包括：是否大小写、符号错误或者是缺少、单词是否拼写<br>正确等<br>运行时期：<br>检查的就是逻辑<br>总结：</li>
<li>print 和 println 区别：<br>print 打印完内容后不换行<br>println 打印文内容后光标移动到下一行的开始位置，即换行<br>转义字符：<br>\n: 换行<br>\t: 相当于是键盘上的 tab 键，水平制表符</li>
<li>一个类中只能有一个 main 入口</li>
<li>类名不能使用数字开头</li>
<li>如果类用 public 修饰了，则表示是公共类，必须类名和源文件名必须<br>一致</li>
<li>一个 java 文件中可以写多个类，编译后生成对应个数的类文件</li>
<li>类名命名：<br>一个单词组成，单词首字母大写<br>多个单词组成，每个单词的首字母大写，单词间没空格<br>见名知意<br>任务：<br>1、注释、关键字、标识符<br>2、常量和变量<br>3、数据类型及数据类型间转换<br>4、运算符<br>注释、关键字、标识符<br>注释：</li>
<li>注解说明程序<br>单行注释： //<br>多行注释： /<em>…..</em>/ 注意：多行不能嵌套多行<br>文档注释： /<em>*….</em>/ 注意：文档不能嵌套使用</li>
<li>调试程序<br>要养成写注释的习惯。<br>关键字：<br>在 java 中有一些单词被赋予了特殊的含义。<br>关键字都是小写形式。<br>注意：const 和 goto 在 java 中并没有使用，保留字。<br>标识符：<br>凡是让我们自己定义名字的地方，包含：类名、变量名、方法名、常<br>量名<br>规则：</li>
<li>字母、数字、_、$组成</li>
<li>不能是数字开头</li>
<li>不能是 java 中的关键字</li>
<li>区分大小写<br>规范：<br>类名： Xxx XxxYyyZzz<br>变量名： xxx xxxYyyZzz 名词<br>方法名： xxx xxxYyyZzz 动词<br>常量名： XXX XXX_YYY_ZZZ<br>常量：<br>不能改变的数据。<br>数值型：<br>整数类型： 123， 35<br>浮点类型： 1.23<br>字符类型：<br>用一对单引号表示，中间只能放一个内容，内容可以是字母、数字、符<br>号、汉字等<br>‘a’ , ’1’, ’ ’, ’中’<br>字符串类型：<br>用一对双引号表示，中间可以放大于等于 0 个以上的内容。<br>“” “abc” “123” “ ” “中国你好”<br>布尔类型：<br>用来表示是否成立，true ，false<br>null 常量：<br>null<br>变量：<br>java 语言是一个强类型语言，每操作一个数据都需要有对应的数据类型表<br>示。<br>字面理解为：可以改变的数据。<br>可以理解为是一个容器，用于存储可以变化的数据。<br>实质：在内存中开辟一个空间需指定空间类型(数据类型)，<br>用于存储可以改变(只能在确定的类型范围内)的数据<br>声明格式：<br>数据类型 变量名;<br>赋值：<br>变量名 = 数据;<br>声明并赋值：<br>数据类型 变量名 = 数据;<br>数据类型：<br>基本类型(简单)：<br>java 中使用关键字表示的类型，确定每个类型的范围及空间的大<br>小。<br>整数类型：<br>byte : 1 个字节， 8bit， -128<del>127 0</del>255<br>short：2 个字节， 16bit， -2^15 ~ 2^15-1<br>int : 4 个字节， 32bit， -2^31 ~ 2^31-1 默认类型<br>long: 8 个字节， 64bit， -2^63 ~ 2^63-1<br>浮点类型：<br>float：单精度，4 个字节<br>double：双精度，8 个字节 默认<br>字符类型：<br>char：2 个字节 ‘a’ ‘中’<br>布尔类型：<br>boolean： true /false<br>引用类型(复合)：<br>存储的是对象的地址值。<br>数组，类，接口，枚举<br>注意：</li>
<li>在一对大括号中不能出现同名的变量名</li>
<li>变量必须有初始值后，才能使用。<br>数据类型间的转换：<br>自动转换： 小类型—&gt;大类型<br>byte short char —&gt; int —&gt; long –&gt;float—&gt;double<br>记住：操作数中出现了浮点类型，最终结果为浮点类型。<br>强制转换： 大类型—-&gt;小类型<br>格式：(要转换的类型)<br>注意：有可能降低数据的精度，不建议使用。<br>总结：boolean 不参与转换。<br>运算符<br>算术运算符<br>赋值运算符<br>比较运算符<br>逻辑运算符<br>三元运算符<br>位运算(了解)<br>算术运算符：</li>
</ol>
<p>+(正号) -(负号) </p>
<ul>
<li><ul>
<li><ul>
<li>/ %(取模、取余数) </li>
</ul>
</li>
</ul>
</li>
<li>+(自增) –(自减)<br>作用：当前数据做+1(-1)的求和(差)元素。</li>
<li>(字符串连接符)<br>字符串： 引用类型<br>String s = “abc”;<br>复习：<br>1、注释，关键字，标识符<br>2、常量和变量<br>常量：固定不变的数据<br>整型，浮点型，字符，字符串，布尔，null<br>变量：可以在指定类型的范围内改变的数据<br>格式：<br>数据类型 变量名 = 数据;<br>数据类型：<br>引用类型：数组，类，接口，枚举<br>字符串： String<br>基本类型：<br>整数：byte short int long<br>浮点：float double<br>字符：char<br>布尔：boolean<br>数据类型间的转换：<br>自动转换：小类型自动转为较大的类型(隐式完成)<br>byte short char —&gt;int —&gt;long—&gt;float—&gt;double<br>运算时遇到浮点类型最终结果为浮点类型<br>强制转换：大类型转为小类型(显式完成)，格式:(要转换的类型)<br>注意：boolean 不参与转换。<br>3、算术运算符</li>
<li><ul>
<li><ul>
<li>/ % ++ – +(字符串连接符)<br>赋值运算符：<br>简单：=<br>规则：先计算等号右边，将结果赋值给左边(两步完成赋值)<br>扩展：+= -= *= /= %=<br>好处：</li>
</ul>
</li>
</ul>
</li>
</ul>
<ol>
<li>提高了运算效率</li>
<li>自动完成强转操作<br>缺点：<br>两个操作数做运算，值为其中的一个操作数时<br>比较运算符：<br>运算后的结果一定是：boolean 类型<br>== ：比较左右两边是否相等，相等返回 true，否则为 false<br>!= ：比较左右两边是否不相等，不相等返回 true，否则为 false <blockquote>
<blockquote>
<p>= &lt; &lt;=<br>逻辑运算符：<br>作用：用来连接值为 boolean 类型的表达式。<br>运算后的结果：boolean 类型<br>&amp;（与，并且）：两边都是 true，则为 true；否则全为 false<br>|（或）:两边都是 false，则为 false；否则为 true<br>！（非）: 取反，!true = false, !false = true<br>^（异或）：两边相同为 false，两边不同为 true<br>&amp;&amp;: 短路与<br>如果左边表达式计算结果为 false，则直接判定结果为 false，右边不再<br>计算。<br>||: 短路或<br>如果左边表达式计算结果为 true，则直接判定结果为 true，右边不再计<br>算。<br>三元(目)运算符：<br>格式：<br>boolean 类型的表达式 ? 表达式 1 : 表达式 2;<br>运算规则：<br>先计算 boolean 类型的表达式，结果为 true，则最终结果为表达式<br>1；<br>如果结果为 false，则最终结果为表达式 2；<br>由于是运算符，计算后一定会产生一个数据，数据是多少不确定，<br>通常存储到一个变量中。<br>位运算：<br>需要将要操作的数据转为二进制数据才可以运算。<br>逻辑位运算：<br>&amp; | ^<br>1 = true<br>0 = false<br>移位位运算：<br>左移： &lt;&lt;<br>被移位的数 乘以 2 的移动次幂<br>右移： &gt;&gt;<br>被移位的数 除以 2 的移动次幂<br>最高位补位与被移位的数的是正数和负数有关，正数补位是 0，负<br>数补位是 1。<br>无符号右移： &gt;&gt;&gt;<br>最高位补位与被移位的数的是正数和负数无关，补位都是 0。<br>键盘录入：<br>步骤：</p>
</blockquote>
</blockquote>
</li>
<li>在声明类的上边写生一条语句： import java.util.*; </li>
<li>创建一个扫描器，目的通过该扫描器扫描用户输入的数据<br>Scannerer 名字 = new Scanner(System.in); </li>
<li>使用扫描器扫描整数,将扫描到的数据存储到变量中<br>int 变量名 = 名字.nextInt();<br>流程控制语句：<br>顺序流程：<br>从上到下，逐行执行。<br>分支流程：<br>从上到下，执行过程中某些代码跳过不执行。<br>循环流程：<br>从上到下，执行过程中某些代码重复执行多次。<br>分支流程：<br>判断语句：<br>if(判断语句 boolean){<br>逻辑语句;…..<br>}<br>if(boolean 条件){<br>逻辑语句;….<br>}else{<br>逻辑语句;….<br>}<br>三元运算符是 if-else 语句的一种简写格式。<br>当能最终产生一个数值时可以互换使用。<br>多重条件判断<br>if(条件 1){<br>….<br>}else if(条件 2){<br>….<br>}else if(条件 3){<br>…..<br>}…..else{<br>….<br>}<br>//嵌套语句<br>if(){<br>if(){<br>}<br>}<br>如果控制的语句有且只有一行时，大括号可以省略不写。<br>选择语句：<br>switch(表达式){ // byte short char int String 枚举<br>case 常量值 1:<br>语句;…..<br>break; //结束<br>case 常量值 2:<br>语句;…<br>break;<br>……<br>default:<br>语句;…<br>break;<br>} </li>
<li>switch 语句结束的标志：break; 和 } </li>
<li>switch 语句中可以没有 default </li>
<li>switch 语句中的 case 是没有顺序的</li>
<li>switch 语句中的 break 语句可以没有<br>程序会继续向下执行，只要遇到 case 就执行，不在进行匹配，<br>直至遇到结束标志才停止——–穿透性。<br>if 和 switch：</li>
<li>如果表达式的值是 boolean 类型，用 if 语句<br>其他类型用 switch 语句</li>
<li>如果是区间判断判断用 if 语句<br>如果是等值情况，建议用 switch 语句，效率稍高。<br>复习：<br>运算符：<br>赋值： = += -= /= *= %=<br>比较：== != &gt; &gt;= &lt; &lt;= boolean<br>逻辑： &amp; | ! ^ &amp;&amp; ||<br>三元： boolean 表达式 ? 表达式 1 : 表达式 2;<br>位运算： &amp; | ^ &lt;&lt; &gt;&gt; &gt;&gt;&gt; 二进制数<br>分支语句：<br>判断语句：<br>if(boolean 表达式){}<br>if(boolean 表达式){<br>}else{<br>}<br>if(boolean 条件 1){<br>}else if(boolean 条件 2){<br>}……else{<br>}<br>if(){<br>if(){<br>}<br>}<br>选择语句：<br>switch(表达式){ 类型：byte short char int String 枚举<br>case 常量值 1:<br>…..<br>break;<br>case 常量值 2：<br>…….<br>break;<br>…….<br>default:<br>……<br>}<br>任务：<br>循环语句<br>要素：<br>重复执行语句，条件，初始化变量，更改初始化变量语句<br>循环语句结束的标志：条件值，条件值为 false 则停止。<br>while 语句：<br>while(条件){<br>重复执行语句;<br>}<br>执行顺序为：先判断，后执行<br>执行次数为： 0-n<br>do-while 语句：<br>do{<br>重复执行语句;<br>}while(条件);<br>执行顺序为：先执行，后判断<br>执行次数为：1-n<br>实际开发中：while 用的多，do-while 用的少<br>如果需求要求无论循环条件是否成立，都至少要执行一次必须使用 do￾while<br>for 语句：<br>for(初始化语句；条件语句； 改变初始化语句){<br>重复执行语句；<br>}<br>现在定义的变量：局部变量<br>局部变量都有作用域，在哪里定义，那么这个作用域就在哪。<br>当超出作用域时，这个变量在内存中也就释放了。<br>while 和 for：</li>
<li>已知循环执行的次数，使用 for<br>逻辑判断条件的，使用 while </li>
<li>定义的变量仅限用于循环语句中时，使用 for<br>无限循环(死循环)：<br>while(true){}<br>for(;;){}<br>do{<br>}while(true);<br>跳转语句：<br>break;<br>只能使用在 switch 语句和循环语句中。<br>当前语句结束。<br>continue;<br>只能使用在循环语句中。<br>结束当前正在进行中的此次循环，继续下一次循环。<br>复习：<br>循环语句：<br>要素： 循环条件，重复语句，初始化变量，更改初始化变量语句<br>while(){<br>}<br>do{<br>}while();<br>while 和 do-while: </li>
<li>语句格式不同</li>
<li>执行顺序不同</li>
<li>执行次数不同<br>for(初始化语句; 条件; 更改语句){<br>}<br>局部变量：</li>
<li>都有作用域</li>
<li>必须有初始值<br>无限循环：<br>循环语句不能停止，一直执行。<br>while(true)<br>do-while(true)<br>for(;;)<br>嵌套格式：<br>for(){ 行数<br>for(){} 列数<br>}<br>跳转语句：<br>break；： switch 和 循环<br>当前语句结束<br>continue； 循环<br>结束本次正在进行中的循环，继续下一次循环。<br>任务：<br>方法<br>数组<br>方法：<br>定义在类中，完成一个特定功能的计算， 可以多次调用执行。。<br>格式：<br>修饰符 返回值类型 方法名(参数类型 参数名,参数类型 参数名,…){<br>逻辑语句;<br>return 返回值;<br>}<br>修饰符：public static 或者 static<br>返回值类型： 方法执行完的结果的数据类型<br>分两种情况： </li>
<li>有具体类型</li>
<li>无具体类型表示 void<br>方法名： 自定义(见名知意)， xxx xxxYyyZzz<br>参数列表：<br>多个变量的声明，个数可以是 0 个，也可以是多个(eg:int a)<br>目的：<br>接收数据，完成功能计算。<br>return：</li>
<li>将方法计算后的结果，返回给调用者</li>
<li>结束方法<br>注意：如果方法的返回值类型为 void，则通常 return 关键字省略不<br>写，<br>编译器会自动补全。<br>如果方法的返回值类型为具体类型，则必须有 return。<br>好处：提高代码的复用性<br>注意：自定义方法必须被调用，才可以执行<br>调用格式：</li>
<li>有返回值类型<br>返回值类型 变量名 = 方法名(实参); </li>
<li>无返回值类型 void<br>方法名(实参);<br>自定义方法时考虑：</li>
<li>返回值类型</li>
<li>参数列表<br>方法重载：<br>在一个类中，可以定义多个同名方法，只要参数列表不同即可，与<br>返回值类型无关。<br>参数列表不同： 顺序不同，个数不同，类型不同<br>针对的是：方法功能很相似的方法。<br>数组：<br>可以理解为是一个容器，用于存储一组相同类型的数据。<br>特点：</li>
<li>每存储一个数据，该数据就会有一个下标(角标)，从 0 开始</li>
<li>必须指定大小</li>
<li>既可以存储基本类型数据也存储引用类型</li>
<li>有一个.length 属性，获取数组的长度， 数组名.length<br>获取数组的最大下标值：数组名.length-1<br>创建格式：<br>容器中存储的数据称之为元素。<br>动态创建：<br>元素类型[] 数组名 = new 元素类型[元素个数];<br>静态创建：<br>元素类型[] 数组名 = new 元素类型[]{元素 1，元素 2，元素 3，…..};<br>元素类型[] 数组名 = {元素 1，元素 2，元素 3，…..};<br>增强 for 循环语句 （jdk5）<br>作用：用于遍历数组或者是集合元素<br>格式：<br>for(元素类型 变量名 ：数组){<br>…..<br>}<br>复习：</li>
<li>环境搭建、环境变量配置、程序编写和编译<br>JVM、JRE、JDK<br>系统变量—path<br>编译 ： javac 文件名.java<br>运行 ： java 类名</li>
<li>注释 、标识符、关键字<br>变量和常量<br>变量定义格式： 数据类型 变量名 = 数据;<br>数据类型：<br>基本类型：<br>整数类型 ： byte short int long<br>浮点类型 ： float double<br>字符类型 ： char<br>布尔类型 ： boolean<br>引用类型：数组 类 接口 枚举<br>数据类型间的转换：<br>自动转换： 小类型—-》大类型<br>强制转换： 大类型—-》小类型 （要转换的类型）<br>运算符：<br>算术：+ - * / % ++ –<br>赋值：= += -= *= /= %=<br>比较：boolean == != &gt; &gt;= &lt; &lt;=<br>逻辑：boolean &amp; | ! ^ &amp;&amp; ||<br>三元：boolean 表达式 ? 表示式 1 ： 表达式 2；</li>
<li>流程控制语句<br>判断语句：<br>if(boolean 类型){}<br>选择语句：<br>switch(表达式) //byte short int char String 枚举<br>循环语句：<br>while 、do-while、for<br>跳转语句：<br>break： switch 和 循环<br>continue ：循环中</li>
<li>方法<br>定义在类中，用于完成一个功能的计算<br>修饰符 返回值类型 方法名(参数列表){<br>。。。。。<br>return 返回值;<br>}<br>方法只有调用才会执行。<br>方法重载：<br>在类中，允许方法名相同，要求，参数列表不同，与返回值类型无<br>关。</li>
<li>数组<br>用于存储一组类型相同的数据，相当于一个容器。<br>特点：</li>
<li>长度固定</li>
<li>有下标</li>
<li>.length<br>格式：<br>动态：<br>数据类型[] 数组名 = new 元素类型[个数];<br>静态：<br>数据类型[] 数组名 = {元素 1，元素 2，….};<br>数组内存分配：<br>栈、堆、方法区 （寄存器，本地方法区）<br>栈：<br>方法执行，因此局部变量都存储在栈中<br>方法执行完及释放。<br>先进后出特点。<br>堆：<br>new 出现，则在堆中开辟空间。<br>存储：对象<br>特点：</li>
<li>开辟空间后，会为其分配地址值</li>
<li>存储默认值<br>整型： 0 浮点型：float:0.0f double 0.0<br>字符型: ‘\u0000’ boolean ： false<br>引用： null </li>
<li>容器没有任何引用所指向时，该容器为垃圾<br>等待垃圾回收机制回收(GC)即可。<br>引用变量值为 null，该容器即为垃圾。<br>值传递和引用传递：<br>值传递：基本类型，仅仅数值的传递<br>引用传递：引用类型，地址值的传递<br>可变参数：jdk5.0<br>指的就是方法上的参数列表（数据类型 变量名）。<br>指的是参数个数可以改变，但是类型始终不变，个数&gt;=0。<br>格式:<br>数据类型… 参数名<br>可变参数实质就是一个数组，当调用该方法时则会创建一个数组。<br>注意：<br>只能放在参数列表中的最后，并且只能出现以下。<br>二维数组<br>容器里存储的容器，里边的容器存储的真实数据。<br>格式：<br>动态创建：<br>元素类型[][] 数组名 = new 元素类型[长度][元素个数];<br>eg: int[][] arr = new int[2][3];<br>元素类型[][] 数组名 = new 元素类型[长度][];<br>eg: in[][] arr = new int[2][];<br>静态创建：<br>元素类型[][] 数组名 = new 元素类型[][]{ {元素 1，元素 2，…},{},….};<br>元素类型[][] 数组名 = { {元素 1，元素 2，…},{},….}; //简写格式<br>获取元素个数：数组名.length<br>获取元素的元素个数：数组名[下标].length<br>面向对象：<br>封装 继承 多态<br>理解思想：<br>面向过程：<br>注重强调的是：过程； 执行者角色<br>面向对象：<br>注重强调的是：对象； 指挥者角色<br>思路：<br>找对象(创建对象)–调用其功能<br>类和对象的区别：<br>类：相同类型事物的一组属性和行为的集合<br>class 人{<br>//属性 特征 变量<br>int age;<br>String name;<br>…..<br>//行为 做事 方法<br>void eat(){}<br>void sleep(){}<br>void play(){}<br>……<br>}<br>对象： 该类事物的真实的一个个体。<br>人 张三 = new 人(); //创建对象<br>张三.eat(); //让张三去吃饭<br>创建对象：<br>类名 对象名 = new 类名();<br>访问对象的属性和行为(属性和行为都叫做类的成员)<br>对象名.属性名<br>属性有两个操作获取和设置。<br>对象名.方法名(实参);<br>复习：<br>数组的内存：<br>栈：<br>方法执行，执行完出栈<br>先进后出<br>堆：<br>new 出现，在堆中开辟空间。</li>
<li>会分配内存地址值</li>
<li>存储默认值</li>
<li>垃圾回收机制会进行不定时启动处理垃圾<br>没有任何引用所执行的容器，则称之为垃圾。<br>数组异常：</li>
<li>数组下标越界 ArrayIndexOutOfBoundsException </li>
<li>空指针异常 NullPointerException<br>二维数组：<br>动态创建：<br>元素类型[][] 数组名 = new 元素类型[一维数组的个数][一维数组的元素<br>个数];<br>数组名[0] 地址值<br>元素类型[][] 数组名 = new 元素类型[一维数组的个数][];<br>数组名[0] null<br>数组名[0] = new 元素类型[个数];<br>静态创建：<br>元素类型[][] 数组名 = new 元素类型[][]{ {元素，….},{},{}….};<br>元素类型[][] 数组名 ={ {元素，….},{},{}….};<br>面向对象：<br>一种思想，执行者转换为指挥者。<br>找对象(创建对象)—-调用其功能<br>类和对象:<br>类： 描述一类事物的一组相同属性和行为的集合—class<br>属性：变量<br>行为：方法<br>对象：该类事物的一个具体实体—new<br>成员变量和局部变量区别：</li>
<li>声明位置<br>成员变量定义在类中<br>局部变量定义方法中</li>
<li>作用域<br>成员变量整个类中都可以使用<br>局部变量只能在它所属的局部位置使用</li>
<li>内存位置<br>成员变量存储在堆中<br>局部变量存储在栈中</li>
<li>是否初始值<br>成员变量有默认值，因此不需要赋初始值就可以使用。<br>局部变量必须有初始值才可以使用</li>
<li>生命周期<br>成员变量随着对象的创建而存在，随着被回收则消失<br>局部变量随着方法进栈则存在，随着方法出栈则消失<br>对象的实例化过程(对象的创建过程–内存)：<br>Student s = new Student（）; </li>
<li>main 方法进栈执行，产生一个局部变量 s </li>
<li>在堆中开辟空间，并分配内存地址值</li>
<li>存储默认值(取决于数据类型) </li>
<li>如果有显示初始化，则进行显示初始化</li>
<li>地址值赋值给左边的 s 变量<br>匿名对象：<br>创建的对象没有名字，即没有引用变量<br>这是一种创建对象的简写格式，是简写就有弊端。<br>访问属性：<br>没什么意义，操作完该对象即成为垃圾，不能对该对象做其他操<br>作。<br>想要对同一个对象的属性进行多次操作，必须起名字。<br>访问方法：<br>对于一个对象来说，只能调用一次方法，通常这种方式都是用来测<br>试方法的。<br>想要多次调用或者调用其他方法那么必须给对象起名字。<br>匿名对象可以作为参数进行传递。<br>面向对象：<br>封装 继承 多态<br>封装：将对象的属性或行为隐藏起来，对外提供公共的访问方式。<br>private： 私有的意思，是一个修饰符，用于修饰类中的成员。<br>被修饰的成员称为私有成员，只能当前类中访问。<br>方法：<br>方法名是有固定规范的<br>设置： set 属性名 setName<br>获取： get 属性名 getName<br>问题：<br>成员位置和局部位置变量名重名问题。<br>解决办法：<br>this 关键字：代表的是对象的引用。<br>谁调用 this 所在的方法，那么 this 就代表谁。<br>构造方法：<br>也是方法，只不过比普通方法特殊一些。<br>普通方法：<br>修饰符 返回值类型 方法名(参数列表){<br>…..<br>return 返回值；<br>}<br>调用：方法名(实参);<br>构造方法：<br>修饰符 方法名(参数列表){<br>….<br>}<br>方法名： 类名<br>支出方法重载<br>没有返回值类型，但是可使用 return；<br>什么时候执行？<br>当创建对象时，new 关键字后边写的内容即是调用的构造方法。<br>对于一个对象来说，构造方法只执行一次。<br>作用：<br>主要是用于给对象的属性进行初始化。<br>注意：</li>
<li>构造方法可以调用普通方法</li>
<li>普通方法不能调用构造方法</li>
<li>系统默认在类中添加了无参数的构造方法，但是一旦自己编<br>写了构造方 法那么系统不再提供。<br>重载构造方法调用：<br>this(实参)语句完成。<br>注意：</li>
<li>该语句必须放在构造方法的第一行。优先执行。</li>
<li>类中的重载构造方法的第一行至少有一个不能存在 this(实参)<br>语句。<br>问题：<br>构造方法是用于属性初始化，那么 set 和 get 方法还有必要存在?<br>有。因为构造方法只执行一次， set 和 get 可以多次被调用执<br>行，想要属性的更改只能使用 set 方法。<br>对象的实例化过程(对象的创建过程–内存)：<br>Student s = new Student（“张三”，20）; </li>
<li>main 方法进栈执行，产生一个局部变量 s </li>
<li>在堆中开辟空间，并分配内存地址值</li>
<li>存储默认值(取决于数据类型) </li>
<li>如果有显示初始化，则进行显示初始化</li>
<li>执行构造方法</li>
<li>地址值赋值给左边的 s 变量<br>复习：<br>类和对象：<br>类：抽象的概念，一组属性和行为—class<br>对象：真实存在的个体—new<br>成员变量和局部变量的区别：</li>
<li>定义位置</li>
<li>有无初始值</li>
<li>作用域</li>
<li>内存存储位置</li>
<li>生命周期<br>匿名对象：<br>没有引用变量所指向的对象。<br>匿名对象操作属性没有意义，操作完该对象就称为垃圾了。<br>匿名对象操作方法有点意义，但是只能调用一次方法。<br>匿名对象可以作为实参进行参数传递。<br>面向对象： 封装 继承 多态<br>封装：将对象的属性或者是行为隐藏起来，对外提供公共访问方式。<br>private：私有的意思，修饰符<br>可以修饰类中的成员，只能在当前类中使用。<br>public：公共的意思，修饰符，整个项目都可以访问。<br>私有属性需要对外提供两个公共方法，一个是用于获取另一个是用<br>于设置。<br>因此这两个方法有默认的规范方法命名，格式 set 属性名() get 属<br>性名()<br>this 关键字：</li>
<li>解决局部位置和成员位置变量名重名问题<br>作用：代表对象的引用，谁调用代表谁</li>
<li>调用重载的构造方法<br>构造方法：<br>特殊的方法。<br>修饰符 类名(参数列表){<br>……..<br>}<br>当创建对象时，根据 new 关键字后边的格式调用对应的构造方法执<br>行，只执行一次，作用是用于给对象的属性进行初始化。<br>注意：类中可以不定义构造方法，系统会提供一个构造方法，用于<br>能建立对象，<br>默认格式：无参数的构造方法。一旦类中定义了，则不再提<br>供。<br>支持方法的重载。<br>调用重载的构造方法使用：this(实参);语句，这条语句必须放在构<br>造方法的第一行。<br>构造方法中可以调用其他方法，但是其他方法不能调用构造方法。<br>构造方法存在，set 方法依旧要存在，因为构造方法只是对象创建那<br>一刻执行，而 set 可以多次被调用执行。<br>对象的实例化过程：<br>Person p = new Person(“张三”,19); </li>
<li>加载 Person.class 进内存</li>
<li>方法进栈执行</li>
<li>在堆中开辟空间，并分配内存地址值</li>
<li>在空间中，根据属性的类型，存储默认值</li>
<li>如果属性有初始值则，进行显示初始化</li>
<li>执行构造方法</li>
<li>将对象的地址值赋值给 p 引用变量<br>static 关键字：<br>修饰符，静态的意思，修饰类中的成员。<br>修饰变量：<br>称为类变量，静态变量，与对象无关。<br>特点：</li>
<li>随着类的加载而加载，随着类的消失而消失</li>
<li>优先于对象存在内存中</li>
<li>被所有对象所共享</li>
<li>生命周期较长</li>
<li>两种访问方式：<br>① 对象名.静态变量名<br>② 类名.静态变量 —建议<br>注意：只能是数据被所有对象所共享时，才使用 static 修饰，否则<br>不能使用。<br>比如： 投影仪，桌面共享。<br>修饰方法:<br>称为类方法，静态方法，与对象无关。<br>访问方式：</li>
<li>类名.静态方法 —–建议</li>
<li>对象名.静态方法<br>访问局限：</li>
<li>静态方法只能访问静态成员</li>
<li>非静态方法既可以访问静态也可以访问非静态</li>
<li>在静态方法中不能出现 this 和 super 关键字<br>注意：一般该类是一个工具类时，才使用静态修饰方法。<br>方法区：<br>存储 class 文件。<br>分为：静态区域，非静态区域<br>main 方法：<br>public static void main(String[] args){}<br>public: 修饰符，公共的意思，访问权限最大。<br>static：静态的意思，不需要创建对象就可以调用<br>void：无返回值类型，该方法只是执行，不需要返回结果。<br>main：方法名，不是 java 中关键，但是要当成关键字去看待<br>String[]:字符串形执行式的数组，目的是用于接收一些数据参与程<br>序运算。<br>基本不再使用这种方式，使用 Scanner 完成操作。<br>工具类：<br>就是一个类，该类中封装了很多的静态方法，帮助完成我们的需<br>求。<br>可以多个程序都可以使用。<br>比如：<br>数组工具类<br>方法：</li>
<li>遍历</li>
<li>获取最值</li>
<li>排序</li>
<li>查找</li>
<li>私有构造方法，目的不让其能创建对象<br>为了方便给其他人使用，通常可以生成帮助文档<br>javadoc -d 目录 工具类名.java<br>注意：目的中存放的网页文件，因此大家只要看 index.html 文件<br>java 中提供好的帮助文件，API，application programming interface。<br>java.uti.Arrays： 数组工具类<br>sort() :排序<br>toString():将数组元素转为字符串<br>fill(数组，数据)：用数据替换数组中的所有元素<br>binarySeach(数组，数据):查找数组是否有指定的数据，前提需要将数组排<br>序。<br>代码块：<br>局部代码块：<br>格式：<br>{<br>代码<br>}<br>需要放在局部位置上，即放在方法中。<br>作用：就是用于控制局部变量的作用域。<br>构造代码块：<br>格式：<br>{<br>代码<br>}<br>需要定义在类中，优先于构造方法执行<br>作用：用于给所有对象进行统一初始化<br>在一个类中，可以有多个构造块，从上到下依次执行，执行完后执行<br>对应的构造器<br>静态代码块：<br>格式：<br>static{<br>…<br>}<br>需要定义在类中，随着类的加载而执行，由于类只加载一次，因此<br>静态代码块也只执行一次。作用：在类加载时需要完成的操作，比如：加载驱<br>动。<br>在一个类中，可以有多个静态块，从上到下依次执行，都只执行一<br>次。<br>继承：<br>类与类间有了关系，继承关系， extends<br>为什么要出现继承？<br>想要提高代码的复用性。<br>从一个类中，创建出多个类的过程—继承，其中原有的类称之为：父类、<br>超类、基类<br>创建出的类称之为：子类。<br>子类继承父类后，那么子类就继承了父类中的成员(构造方法除外)。<br>在 java 中，一个子类只能有一个父类——单继承<br>对于一个父类来说，可以有多个子类。<br>在 java 中，虽然只能是单继承，但是允许一个子类有父类，父类上边还有<br>父类,…..形成了一个继承体系，类似现实生活中的家谱。在继承体系中，最顶层<br>的父类中定义的内容是整个体系中最共性的内容，最底层的子类中定义的功能<br>是最多的，所以学习一个体系，从上到下去学习，先学习最顶层父类，建立对<br>象建立子类。<br>注意：</li>
<li>不能因为想要提高代码的复用性，而乱使用继承，必须是有 is—<blockquote>
<p>a 的关系才可以使用。比如： Dog 类，eat 方法； Cat 类，eat 方法，不能<br>因为这两个类中都有 eat 方法而让 dog 继承 cat，或者是 cat 继承 dog。dog<br>和 cat 都属于 animal，因此可以将 dog 和 cat 中相同的内容进行向上抽取，<br>抽到到 Animal 类中，让 dog 继承 animal，cat 继承 animal。</p>
</blockquote>
</li>
<li>子类继承父类后，构造方法不被继承<br>因为如果被继承了，构造方法的名字需要与类名一致，和这一点矛<br>盾。</li>
<li>私有成员，子类对象不可以直接进行访问，想要访问，只能通过<br>对外提供的 set 和 get 方法进行访问。<br>在 java 中，最顶层的根类：Object。<br>继承出现后，类中成员的变化：</li>
<li>变量<br>子父类中出现了同名的变量，创建子类对象，访问该变变量，运行的是<br>子类的结果。<br>this 和 super：<br>它俩的用法是一样的，只不过 this 代表的是当前类对象的引用，相<br>当于是“自己”的意思；而 super 代表的是父类对象的引用。<br>实际开发中，子父类中基本上不会出现同名的变量。</li>
<li>方法<br>子父类中出现了相同的方法声明，但是方法的方法体内容不同，创<br>建子类对象，调用该方法，运行的结果为子类内容，相当于继承的方法被<br>覆盖了一样，这种现象称之为：方法的覆盖或者是方法的重写。<br>方法重写(override)：子类重写父类的方法<br>方法重载(overload)：在一个类中，方法名相同，参数列表不同，<br>与返回值类型无关。<br>什么时候进行方法重写？<br>继承的方法的方法体不满足子类的需求，但是方法的声明又不想要改<br>变时。如果想要父类的该方法也执行起来，则使用 super 关键字调用。<br>方法重写条件：</li>
<li>子类重写父类方法时，访问权限修饰符大于等于父类。</li>
<li>返回值类型、方法名和参数列表要和重写方法保证一致</li>
<li>如果父类方法为 private 则一般不会重写。<br>验证某个方法是否是重写方法，可以在方法声明的上边：<br>@Override 注解</li>
<li>构造方法<br>在子类构造方法的第一行都隐藏着一条语句：super(); 该语句可以去调<br>用父类的无参数构造方法。如果父类中没有无参数构造方法，那么子类必<br>须显示写出 super(实参)语句，并且该语句必须放在构造方法的第一行。<br>为什么要调用父类的构造方法？<br>优先让父类的属性先进行初始化。<br>构造方法的第一行要么是 this()语句要么是 super()，它俩不能同时存<br>在，因为都要在第一行。因此，显示写出了谁，那么第一样都是哪个语<br>句，如果没有显示写出，那么第一行就是 super().<br>子类的构造方法无论有几个重载形式，至少有一个构造方法的第一行是<br>super 语句。<br>编写实体类或者对象类步骤：</li>
<li>私有化属性</li>
<li>无参数和有参数构造方法</li>
<li>set 和 get 方法</li>
<li>返回属性信息方法</li>
</ol>
<p>复习：<br>面向对象：封装 继承 多态<br>封装：<br>将对象的属性或者是行为隐藏(private)起来,对外提供公共(public)访问方<br>式。<br>继承：<br>从一类中衍生出多个类<br>原始类：父类 、超类、 基类<br>新类： 子类<br>好处： </p>
<ol>
<li>提高了代码的复用性</li>
<li>推出第三个特性，多态<br>弊端：<br>类与类间有了关系，导致耦合度增强<br>class 子类 extends 父类{}<br>单继承：<br>一个子类只能有一个父类，一个父类可以有多个子类。<br>子类继承父类后，父类的成员被子类都继承了，子类可以直接使用，但<br>是构造器没有被继承，对于私有成员子类不能直接访问，只能通过 set 或者<br>是 get 方法间接去访问。<br>对于子类来说，不但继承了父类中的成员，还可以有自己特有的属性和行<br>为。<br>注意：</li>
<li>is—&gt;a </li>
<li>允许多重继承，即继承体系，好比家谱<br>a extends b<br>b extends c<br>c extends d….<br>子类继承父类后，类中成员的变化：<br>变量：<br>子父类中，出现同名变量，建立子类对象，访问该变量，结果<br>是子类。<br>方法：<br>子父类中，出现相同的方法定义，但是方法体不同，建立子类<br>对象，调，用该方法，运行的是子类方法，—-方法重写/覆盖。<br>前提条件：</li>
<li>访问权限修饰符大于等于父类</li>
<li>返回值类型、方法名、参数列表要与父类相同</li>
<li>private 方法不覆盖<br>构造方法：<br>子类构造方法的第一行，都有 super()语句，目的调用父类构造<br>方法。<br>this()调用重载构造方法。<br>this 和 super：</li>
<li>this 操作的都是当前类</li>
<li>super 操作的都是父类<br>static：<br>静态的意思，修饰类中的成员，修饰变量和修饰方法。<br>修饰的成员都称之为：类变量和类方法，因此与对象无关。<br>访问方式：</li>
<li>类名.静态成员名</li>
<li>对象名.静态成员名<br>访问局限：</li>
<li>静态只能访问静态，而非静态既可以访问静态也可<br>以访问非静态</li>
<li>静态方法中不能出现 this 和 super 字样<br>代码块：<br>局部代码块<br>作用：控制局部变量作用域<br>构造代码块<br>优先于构造方法执行，给所有对象统一初始化<br>静态代码块<br>因为类只加载一次，静态代码块也只执行一次。<br>用于给类进行初始化。<br>final 关键字：<br>最终的意思，修饰符，修饰类、方法、变量。<br>修饰类：代表该类是一个最终类，意味着不能有子类。<br>修饰方法：代表方法是一个最终方法，意味着不能被重写。<br>修饰变量：可以修饰局部变量也可以修饰成员变量，只要被 final 修饰<br>意味着是最 终变量，即常量，不可以改变。<br>public/private static final 数据类型 常量名 = 数据;<br>常量： XXX_YYY_ZZZ<br>eg ： public static final double MY_PI = 3.14;<br>多态：<br>字面理解为：一个对象的多种形态<br>实质：一个对象可以使用不同类型的引用变量所表示。<br>不同类型引用变量：</li>
<li>本类类型的引用变量</li>
<li>父类型的引用变量<br>通俗易懂： 父类型引用指向自己的子类对象<br>前提条件：<br>必须有继承或者是实现<br>多态形式创建的对象，类中成员的变化：<br>方法：<br>分为编译时期和运行时期<br>编译时期：看父类，父类中有该方法则编译通过<br>运行时期：看子类，因为创建的子类对象，运行的是子类结果<br>变量：<br>无论编译还是运行都看父类。<br>静态方法：<br>无论编译还是运行都看父类。<br>类型转换问题：<br>向上转型 ：父类型引用指向子类对象<br>向下转型： 父类型引用转为子类型引用<br>instanceof： 比较运算符，boolean 类型<br>判断左右两边类型是否一致。<br>抽象类：<br>也是一个特殊的类，声明类时使用一个 abstract 关键字进行了修饰。<br>abstract： 抽象的意思，修饰符，可以修饰类和方法。<br>抽象类的由来：<br>多个子类继承父类后，每个子类都需要将父类中的部分方法进行重写，<br>那么对于父类来说，这些被覆盖的方法就没有必要带方法体，用 abstract 修<br>饰，表示该方法为抽象方法，使用分号结束语句。<br>抽象类特点：</li>
<li>不能实例化，即不能创建对象</li>
<li>抽象方法一定在抽象类中，但是抽象类中不一定有抽象方<br>法，可能一个都没有，目的就是该类不创建对象。</li>
<li>必然有子类，子类继承抽象父类后，子类需要将继承的抽<br>象方法全部重写，否则子类还是一个抽象类。</li>
<li>抽象父类型引用可以指向其子类对象<br>抽象类中的成员：<br>变量、方法、构造方法、抽象方法<br>接口：<br>也是一个特殊的类，使用新的关键字去声明。<br>格式：<br>修饰符 interface 接口名{<br>常量<br>抽象方法<br>}<br>由于接口使用 interface 定义的，因此，类中的成员是固定的，并且<br>成员的修饰符也是固定的。<br>常量： public static final<br>方法： public abstract<br>由于都是固定的修饰符，因此实际编写中，如果漏写了某个修饰<br>符，编译器会自动补全，接口中的成员都是公共成员。<br>特点：</li>
<li>不能实例化，即不能创建对象</li>
<li>子类实现(implements)接口，并实现接口中的全部方法，才<br>能创建子类对象；如果只实现了接口中的部分方法，那么子类依然<br>是抽象类。</li>
<li>接口父类型引用可以指向自己的实现类对象<br>类和类间的关系是：单继承<br>类和接口间的关系是：多实现，<br>即一个类可以实现多个接口，接口名间用逗号分开<br>接口<br>接口和接口间关系：多继承<br>作用：</li>
<li>扩展功能</li>
<li>定义规则<br>简单理解：接口中只负责定义方法的声明格式，具体实现由子类完<br>成。<br>实际开发中：<br>class A extends B implements C,D…{}<br>class a extends b{}<br>class b implements c,d{}<br>eclipse 工具使用：<br>下载后直接解压，找到 eclipse.exe ,双击<br>弹出窗口：选择工具空间，即代码存放位置<br>创建项目：<br>File—右键—project—javaproject—编写项目名<br>创建类：<br>src–右键—class—编写类名等<br>修改字体大写：<br>window—preferences—-<br>basic 的最后一项：<br>快捷键：<br>删除： ctrl+D<br>自动补全： alt+/<br>自动补全 main 方法： main alt+/<br>自动补全输出语句： syso alt+/<br>复制语句： ctrl+all+方向键向上/向下<br>移动代码： alt+方向键向上/向下<br>代码格式化： ctrl+shift+F<br>更改文件名字等： F2<br>加/取消单行注释： ctrl+/<br>加多行注释： ctrl+shift+/<br>取消多行注释： ctrl+shift+\<br>内部类：<br>将一个类定义到另一个类的里边，那么里边的类称之为叫做内部类，外部<br>的类称之为叫做外部类。<br>根据定义位置分为：<br>成员内部类<br>就可以使用成员修饰符进行修饰，比如 private static<br>默认成员内部类</li>
<li>可以声明非静态变量和方法、静态常量。</li>
<li>可以直接访问所属的外部类中的成员，静态、非静态、私有<br>访问内部类中的成员,必须先创建内部类对象</li>
<li>间接方式：<br>在所属的外部类中定义一个方法，用于创建该内部<br>类对象<br>在外部其他类中创建外部类的对象，调用上边的方<br>法</li>
<li>直接方式：<br>在外部其他类中直接访问<br>外部类名.内部类名 变量名 = new 外部类名().new 内部类名<br>();<br>eg： Outer.Inner in = new Outer().new Inner();<br>私有成员内部类<br>具备了私有的特性，只能在它所属的外部类中访问</li>
<li>可以声明非静态变量和方法、静态常量。</li>
<li>可以直接访问所属的外部类中的成员，静态、非静态、私有<br>访问内部类中的成员,必须先创建内部类对象<br>只能通过间接方式：<br>在所属的外部类中定义一个方法，用于创建该内部<br>类对象<br>在外部其他类中创建外部类的对象，调用上边的方<br>法<br>private 可以修饰：变量、方法、类(内部类)<br>静态成员内部类 </li>
<li>可以声明非静态成员也可以声明静态成员</li>
<li>都可以直接访问所属的外部类中的静态成员，想要访问非<br>静态成员必须创建外部类对象才可以。<br>想要访问静态内部类中的成员：<br>非静态成员：需要创建内部类对象去访问<br>静态成员：通过内部类名直接访问<br>局部内部类</li>
<li>可以声明静态常量，非静态成员</li>
<li>可以直接访问所属的外部类中的静态和非静态成员</li>
<li>访问它所在的局部位置上的变量，该变量是需要用 final 修<br>饰的，即访问的变量得是常量。<br>访问局部内部类中成员，需要创建内部类对象，才可以访问。<br>局部内部类具备了局部的特点，只能在所属的局部位置使用，因此<br>对象也需要在局部位置上创建。<br>根据类是否有名字分为：<br>匿名内部类(重点)：<br>没有名字的类，是有名字类的简写格式。<br>前提条件： 必须有继承或者是实现。<br>格式： new 父类名/父接口名(实参){<br>重写方法；<br>特有方法;<br>};<br>因此：实质就是创建一个匿名的子类对象<br>父类名父接口名 变量名 = new 父类名/父接口名(实参){ //多态<br>重写方法；<br>特有方法;<br>};<br>这种方式是给子类对象起了名字，父类型引用指向了子类对象，即多态，但<br>是这种方式创建的对象，只能调用父类和子类中共有的方法，子类特有的方法不<br>能调用；想要调用子类特有的方法只能不给对象起名字，直接调用，并且只能调<br>用一次。<br>匿名内部类使用时，通常情况下不会创建子类特有的方法，基本都是重写父<br>类或者是父接口中的方法，并且方法个数一般是 1-3 个，如果再多则不建议使<br>用。<br>包的概念：<br>包就可以理解为是文件夹或者是目录。<br>作用：告知编译器当前类存储到哪个目录中。<br>好处: </li>
<li>分类管理类文件</li>
<li>可以出现同名的类文件</li>
<li>可以使源文件和类文件分离开<br>声明包格式：<br>package 包名;<br>注意：这条语句在一个文件中只能出现一次，并且只能写在非注释行的最上边。<br>包名：<br>一般都是由小写单词或者是字母组成。<br>多级包名：<br>规范： 公司域名倒置.项目名.模块名.[子模块名]<em>;<br>eg: com.ujiuye.cms.login;<br>映射到物理目录： com/ujiuye/cms/login;<br>带包编译：<br>javac -d 目录 源文件名.java<br>带包执行：<br>注意：如果类中有 package 语句，那么该类名的完整性是为：包名.类名<br>java 包名.类名<br>导包：<br>import：<br>在文件中可以出现多次，写在类声明和 package 语句中间。<br>告知编译器当前类中使用的其他类到哪里去找。<br>格式：<br>import 包名.类名;<br>或者： imprt 包名.</em>;<br>在 java 中，jvm 启动时默认导入 java.lang 包下的所有类。<br>jdk5.0 新特性：<br>静态导入，指的是导入静态成员(变量和方法)。<br>格式：<br>imprt static 包名.类名.静态成员名；<br>imprt static 包名.类名.*；<br>好处：简化了代码的编写，省略了:类名.。<br>弊端：如果过多使用静态导入，则代码的阅读性降低。<br>访问权限控制修饰符：<br>同类 同包 不同包子类 所<br>有<br>public： - - - -<br>protected： - - -<br>默认： - -<br>private： -<br>实际开发中：public 和 private 用的多。<br>API： application programming interface 应用程序接口<br>理解为别人写好的程序，可以直接使用，但是不清楚这些方法如何使用，因此出现了<br>帮助文档，即 API 帮助文档。<br>复习：<br>面向对象：<br>一种编程思想，在 java 世界中，认为任何事物都是对象，都是通过操作对象来完<br>成需求，对象可以是具体的事物，也可以是抽象的事物—–指挥者角色。<br>类和对象的区别：<br>类：同类型的对象的一组相同属性和行为的集合—class。<br>属性：变量； 行为：方法<br>对象：类的一个具体的实例 —–new<br>创建对象：<br>类型 对象名 = new 类型();<br>new 类型();<br>访问对象的属性和行为：<br>对象名.成员名;<br>new 类型().成员名;<br>面向对象：<br>封装 继承 多态<br>封装：<br>将对象的属性或者行为隐藏(private)起来，对外提供公共的(public)访问方式。<br>属性：<br>属性操作两种方式，一个设置，另一个获取<br>因此，方法的名规范：setXxx() getXxx<br>this：</li>
<li>代表对象引用，谁调用代表谁</li>
<li>调用重载构造方法，必须方法在第一行，this(实参);<br>构造方法：<br>修饰符 类名(参数列表){<br>。。。<br>}<br>作用：用于给对象的属性进行初始化<br>注意：构造方法也是方法，因此里边也可以写赋值以外的其他逻辑语句。<br>当创建对象时，根据 new 关键字后边的格式，找到对应的构造方法执行，因<br>为对象只能创建一次，因此构造方法对于该对象来说也只执行一次。<br>继承：<br>目的：提高代码的复用性<br>类与类间有了继承关系，extends<br>单继承： 一个子类只能有一个父类，父类也可以有多个子类<br>多重继承：类似于家谱， a extends b , b extends c, c extends d,…… extends Object<br>子类继承父类后，子类就继承了父类的成员，除了构造方法外。<br>注意：私有成员，子类不可以直接访问，只能通过继承的公共方法间接访问。<br>子类、父类间的成员变化：<br>变量：子类和父类中出现同名变量，建立子类对象，访问该变量，操作的是子<br>类中的变量，想要访问父类中的该变量，使用 super 关键字。<br>this 和 super：用法基本相同，只不过 this 操作的都是当前类，而 super 操作的<br>都是父类。<br>方法：子类和父类中出现相同的方法声明，但是方法的方法体代码不同，创建<br>子类对象，访问该方法，调用的是子类的—方法重写、覆盖。<br>重写有要求：</li>
<li>访问权限修饰符大于等于父类</li>
<li>方法声明的其他地方要求一致<br>方法的返回值类型小于等于父类</li>
<li>private 的方法不重写<br>构造方法：<br>子类构造方法的第一行有一个隐藏的语句，super(),目的调用父类的构造<br>方法，让父类构造方法优先执行。<br>如果父类中没有符合 super()语句格式的构造方法，那么子类必须手动显<br>示写出 super(参数)语句调用父类的构造方法。<br>this 和 super 不能共存，第一行要么是 this 要么是 super,子类构造方法的<br>第一行必须有一个为 super 语句。<br>多态：<br>实质：父类引用指向自己的子类对象。<br>前提：必须有继承或者是实现。<br>类中成员变化：<br>变量和静态方法：<br>无论是编译还是运行，都看父类<br>方法：<br>编译看父类，运行看子类<br>类型转换：<br>向上转型： 父类引用指向子类对象<br>向下转型： 父类型运用强转为子类型引用<br>注意：对象一直都是子类对象，没有变过，改变的是引用类型。<br>instanceof:<br>比较运算符，结果为 boolean<br>判断左右两边的类型是否一致。<br>抽象类：</li>
<li>类中有抽象方法的类</li>
<li>类不能创建对象<br>abstract： 修饰类或者是方法<br>抽象类出现了，则需要有子类<br>成员：变量，方法，构造方法，抽象方法<br>抽象类类型应用可以指向自己的子类对象—–多态<br>接口：<br>interface，与生命类格式一样，就是换了一个声明的关键字。<br>成员：<br>常量和抽象方法<br>接口中的成员都有固定修饰符，因此忘记写某个修饰符，没有关系，编译器会自定补全。<br>常量： public static final<br>抽象方法： public abstract<br>特点：<br>不能创建对象<br>需要有子类，子类实现(implements)接口<br>接口类型引用可以指向自己的实现类型对象—-多态<br>static 和 final:<br>static : 修饰类中的成员<br>final： 修饰类、方法、变量</li>
</ol>

            
                

            
        </div>
        <div class="post-tool">
            <a class="btn-thumbs-up" href="javascript:void(0);" data-cid="52" title="95">
                <i class="fa fa-thumbs-up" aria-hidden="true"></i> 打赏
            </a>
        </div>
        
        <div class="post-tags">标签：
            
            <a href="/blog/tags/hexo/">hexo</a>
            
            <a href="/blog/tags/webx/">webx</a>
            
        </div>
        
    </article>
    
        <p style="text-align: center">本文代表个人观点，内容仅供参考。若有不恰当之处，望不吝赐教！</p>
    
    
    

</div>
<script src="/blog/js/busuanzi.pure.mini.js"></script>


        </div><!-- end #main-->
    </div><!-- end #body -->
    <footer class="footer">
    <div class="footer-inner" style="text-align: center">
        <p>
            <a href="/about" title="关于">关于</a>&nbsp;&nbsp<em>·</em>&nbsp;&nbsp
            <!-- 自定义链接 -->
            <a href="/help" title="帮助">帮助</a>&nbsp;&nbsp<em>·</em>&nbsp;&nbsp
            <a href="/links" title="友链">友链</a>&nbsp;&nbsp<em>·</em>&nbsp;&nbsp
            <a href="/sitemap.xml" title="地图">地图</a>
        </p>
        <p>
            本站已建立&nbsp<a href="/timeline" id="siteBuildingTime"></a>&nbsp天，<a href="https://creativecommons.org/licenses/by-nc-sa/4.0/" target="_blank" rel="licence">采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议创作</a><br>
            ©2017-<span id="cpYear"></span> 基于&nbsp<a href="http://hexo.io" target="_blank" rel="nofollow">Hexo</a>
            ，主题采用&nbsp&nbsp<a href="https://github.com/tangkunyin/hexo-theme-jsimple" target="_blank" rel="bookmark">JSimple</a>
            ，作者&nbsp<a href="https://shuoit.net" target="_blank" rel="friend">纠结伦</a>
            ，Hosted by <a href="https://pages.github.com/" target="_blank" rel="nofollow">GitHub Pages</a>
        </p>
    </div>
</footer>
<script src="/blog/js/SimpleCore.js"></script>

</div>
<!-- search pop -->
<div class="popup search-popup local-search-popup">
    <div class="local-search-header clearfix">
        <span class="search-icon">
            <i class="fa fa-search"></i>
        </span>
        <span class="popup-btn-close">
            <i class="fa fa-times-circle"></i>
        </span>
        <div class="local-search-input-wrapper">
            <input id="local-search-input" spellcheck="false" type="text" autocomplete="off" placeholder="请输入查询关键词">
        </div>
    </div>
    <div id="local-search-result"></div>
</div>
<div class="fixed-btn">
    <a class="btn-gotop" href="javascript:"> <i class="fa fa-angle-up"></i></a>
</div>
<script>
    $(function () {
        var jsi_config = {
            buildingTime: '01/20/2018',
            current: $('.post-tags').length > 0 ? 'post' : 'archive',
            snsQRCode: '/images/sns-qrcode.png',
            donateImg: '/images/donate-qr.png',
            localSearch: { dbPath: '' },
            readMode: 'day'
        };
        
        SimpleCore.init(jsi_config);
        
    });
</script>
</body>
</html>
